package com.taiyi.crm.service.impl;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.taiyi.crm.mapper.PermissionMapper;
import com.taiyi.crm.mapper.RoleMapper;
import com.taiyi.crm.mapper.UserMapper;
import com.taiyi.crm.mapper.UserRoleMapper;
import com.taiyi.crm.pojo.entity.Role;
import com.taiyi.crm.pojo.entity.User;
import com.taiyi.crm.pojo.entity.UserRole;
import com.taiyi.crm.pojo.vo.LayUISelectMVO;
import com.taiyi.crm.service.IUserService;
import com.taiyi.crm.util.LayUITableResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import javax.servlet.http.HttpSession;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

// 类里面所有的方法都加上了事物
// @Transactional
@Service
public class UserServiceImpl implements IUserService {
    private Logger logger = LoggerFactory.getLogger(UserServiceImpl.class);
    @Autowired
    private UserMapper userMapper;
    @Autowired
    private UserRoleMapper userRoleMapper;
    @Autowired
    private RoleMapper roleMapper;
    @Autowired
    private PermissionMapper permissionMapper;

    // 如果当前有事务，则使用事务；如果当前没有事务，则不使用事务。
    //一般用在查询，查询里面不需要回滚机制。
    @Transactional(propagation = Propagation.SUPPORTS)
    @Override
    public LayUITableResult selectByPage(Integer page, Integer limit, User user) {
        // 记录开始的时间
        long begin = System.currentTimeMillis();

        //1、使用PageHelper插件设置分页
        PageHelper.startPage(page, limit);
        //2、执行查询
        List<User> list = userMapper.selectByPage(user);
        //3、使用PageInfo对结果进行包装
        PageInfo pageInfo = new PageInfo(list);
        Integer count = (int) pageInfo.getTotal();//得到总数量

//		try {
//			Thread.sleep(3000);
//		} catch (InterruptedException e) {
//			e.printStackTrace();
//		}

        // 记录结束的时间
        long end = System.currentTimeMillis();
        long takeTime = end - begin;
        if (takeTime > 3000) {
            logger.error("====== 执行结束，耗时：{} 毫秒 ======", takeTime);
        } else if (takeTime > 2000) {
            logger.warn("====== 执行结束，耗时：{} 毫秒 ======", takeTime);
        } else {
            logger.info("====== 执行结束，耗时：{} 毫秒 ======", takeTime);
        }

        return LayUITableResult.ok(count, list);
    }

    // @Transactional的默认值就是Propagation.REQUIRED，可以不用写,表示当前一定要使用一个事物。
    //如果当前的事物没有不存在会自己创建一个新的事物，如果当前已经存在事物就不需要额外创建新的事物，就会加入当前的事物里面。
    // 增删改使用REQUIRED操作。
    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void deleteById(Integer id) {
        userMapper.deleteByPrimaryKey(id);
    }

    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void deleteAll(String ids) {
        String[] idArray = ids.split(",");
        userMapper.deleteAll(idArray);
    }

    @Transactional(propagation = Propagation.SUPPORTS)
    @Override
    public User selectByPrimaryKey(Integer userId) {
        return userMapper.selectByPrimaryKey(userId);
    }

    @Override
    public void insert(User user, String roles) {
        // 将角色插入到数据库中
        int count = userMapper.insert(user);
        // 将角色-权限多对多关系放到角色-权限表中
        String[] roleIds = roles.split(",");
        for (String roleId : roleIds) {
            UserRole userRole = new UserRole(user.getId(), Integer.parseInt(roleId));
            userRoleMapper.insert(userRole);
        }
    }

    @Override
    public Map<String, Object> selectUserAndRoles(Integer userId) {
        Map<String, Object> map = new HashMap<>();
        // 查询user信息放到map中
        User user = userMapper.selectByPrimaryKey(userId);
        map.put("user", user);
        // 查询所有的权限放到map中
        List<Role> roles = roleMapper.selectByPage(new Role());
        List<LayUISelectMVO> list = new ArrayList<>();
        for (Role role : roles) {
            LayUISelectMVO layUISelectMVO = new LayUISelectMVO();
            layUISelectMVO.setId(role.getId());
            layUISelectMVO.setName(role.getSn());
            layUISelectMVO.setStatus(1);
            list.add(layUISelectMVO);
        }
        map.put("allRoles", list);
        // 这个角色User对应的所有角色id的数组放到map中
        List<Integer> userSelectedRoles = userRoleMapper.selectRolesByUserId(userId);
        map.put("selectIds", userSelectedRoles.toArray());

        return map;
    }

    @Override
    public void update(User user, String roles) {
        // 将角色插入到数据库中
        int count = userMapper.updateByPrimaryKey(user);
        // 删除这个角色下面原来的权限
        userRoleMapper.deleteByUserId(user.getId());
        // 将角色-权限多对多关系放到角色-权限表中
        String[] roleIds = roles.split(",");
        for (String roleId : roleIds) {
            UserRole userRole = new UserRole(user.getId(), Integer.parseInt(roleId));
            userRoleMapper.insert(userRole);
        }
    }

    @Override
    public User login(String name, String password, HttpSession session) {
        User user = userMapper.login(name, password);
        return user;
    }

    @Override
    public List<User> selectXiaoShouUser() {
        return userMapper.selectXiaoShouUser();
    }

    @Override
    public void insert_register(User user) {
        userMapper.insert(user);
    }

}